//全局公共方法
//全局公共方法
export const global = {
    //日期数据格式化
    //参数1：(选填)format 类型String 作用：用来确定格式 只能识别特定字符 Y,M,D,h,m,s （默认格式） Y-M-D h:m:s
    //Y：年，M:月，D:日，h:时，m:分，s:秒
    //参数2：(选填)time 类型时间戳 作用：根据时间戳返回，对应格式的时间字符串 （默认）当前日期时间

    //如果什么都不填直接返回当前的日期的 2021-12-01 20:20:18

    //日期自定义数据格式化
    formatDate(format = 'Y-M-D h:m:s', time = null) {
        let date = null

        if (time) {
            date = new Date(time) //时间戳为10位需*1000，时间戳为13位的话不需乘1000
        } else {
            date = new Date()
        }
        let formatArr = ['Y', 'M', 'D', 'h', 'm', 's']
        let timeObj = {
            Y: date.getFullYear(),
            M: date.getMonth() + 1,
            D: date.getDate(),
            h: date.getHours(),
            m: date.getMinutes(),
            s: date.getSeconds()
        }

        for (const key in timeObj) {
            if (timeObj[key] < 10) {
                timeObj[key] = '0' + timeObj[key]
            }
        }

        for (const keyWord of formatArr) {
            if (format.indexOf(keyWord) !== '-1') {
                format = format.replace(new RegExp(keyWord, 'g'), timeObj[keyWord])
            }
        }
        return format
    },
    /**
     * 日期区间，起始时间组件确认时，用于设置结束时间组件的最小值
     * @param {*} timeObj 日期组件返回的对象{value,valStr} value(Date) valStr(格式化的日期)
     * @param {*} minTime 最小值
     * @param {*} startName 开始时间名称
     * @param {*} endName 结束时间名称
     */
    setStartTime(timeObj, obj, startName, endName, minTime = 'minTime') {
        obj[minTime] = timeObj.value
        obj.form[startName] = timeObj.valStr
        obj.form[endName] = ''
    },
    //日期区间
    /**
     *验证获取结束时间前，必须要有起始时间
     * @param {*} timeDemo 结束时间组件demo
     * @param {*} startTime 起始时间值
     */
    checkStart(timeDemo, startTime) {
        if (startTime) {
            timeDemo.toggle()
        } else {
            Notify({
                type: 'warning',
                message: '请先选择开始时间'
            })
        }
    },
    //选择器获取展示文字
    /**
     *返回选项框的文本值
     * @param {*} val 当前form中已选的值
     * @param {*} columns 选项数组
     * @returns 返回选项框的文本值
     */
    getColText(val, columns) {
        for (const col of columns) {
            if (col.value == val) {
                return col.text
            }
        }
    },
    //获取元素高度
    getHeight: (demo) => {
        //demo==>this.$refs.refName
        let height = demo.offsetHeight + 'px'
        return height
    },
    /**
     * 文件路径转 base64
     * @param {*} imgUrl 文件路径路径
     */
    getBase64(imgUrl, callback) {
        window.URL = window.URL || window.webkitURL
        var xhr = new XMLHttpRequest()
        xhr.open('get', imgUrl, true)
        // 至关重要
        xhr.responseType = 'blob'
        xhr.onload = function () {
            if (this.status == 200) {
                //得到一个blob对象
                var blob = this.response
                // 至关重要
                let oFileReader = new FileReader()
                oFileReader.onloadend = function (e) {
                    // 此处拿到的已经是 base64的图片了
                    let base64 = e.target.result
                    callback(base64)
                }
                oFileReader.readAsDataURL(blob)
            }
        }
        xhr.send()
    },
    /**
     * blob转base64
     * @params {*}  blob 后端返的二进制流
     */
    blobToBase64(blob) {
        return new Promise((resolve, reject) => {
            const fileReader = new FileReader()
            fileReader.onload = (e) => {
                resolve(e.target.result)
            }
            fileReader.readAsDataURL(blob)
            fileReader.onerror = () => {
                reject(new Error('文件流异常'))
            }
        })
    },
    /**
     * base64转 url
     * @params {*} blob 后端返的二进制流
     */
    base64ImgtoUrl(dataurl, filename = 'file') {
        const arr = dataurl.split(',')
        const mime = arr[0].match(/:(.*?);/)[1]
        const suffix = mime.split('/')[1]
        const bstr = atob(arr[1])
        let n = bstr.length
        const u8arr = new Uint8Array(n)
        while (n--) {
            u8arr[n] = bstr.charCodeAt(n)
        }
        return global.getObjectURL(
            new File([u8arr], `${filename}.${suffix}`, {
                type: mime
            })
        )
    },
    /**
     * file 转 url
     * @param {*} file  文件对象
     * @returns url
     */
    getObjectURL(file) {
        var url = null
        if (window.createObjectURL !== undefined) {
            // basic
            url = window.createObjectURL(file)
        } else if (window.URL !== undefined) {
            // mozilla(firefox)
            url = window.URL.createObjectURL(file)
        } else if (window.webkitURL !== undefined) {
            // webkit or chrome
            url = window.webkitURL.createObjectURL(file)
        }
        return url
    },
    /**
     * 深拷贝
     * @params {*} obj 要拷贝的对象
     * @returns 拷贝后的对象
     * **/
    deepClone(oldobj) {
        //定义一个变量接收新对象
        let newObj = null
        //判断这个对象还是数组
        //1.如果是数组
        if (oldobj instanceof Array) {
            newObj = []
            oldobj.forEach((item) => {
                newObj.push(item)
            })
            //2.如果是对象
        } else if (oldobj instanceof Object) {
            newObj = {}
            for (var i in oldobj) {
                newObj[i] = deepClone(oldobj[i])
            }
        } else {
            newObj = oldobj
        }
        return newObj
    }
}
